/**
 * @fileoverview Protobufs Int64 representation.
 */
goog.module('protobuf.Int64');

const Long = goog.require('goog.math.Long');
const {assert} = goog.require('goog.asserts');

/**
 * A container for protobufs Int64/Uint64 data type.
 * @final
 */
class Int64 {
    /** @return {!Int64} */
    static getZero() {
        return ZERO;
    }

    /** @return {!Int64} */
    static getMinValue() {
        return MIN_VALUE;
    }

    /** @return {!Int64} */
    static getMaxValue() {
        return MAX_VALUE;
    }

    /**
     * Constructs a Int64 given two 32 bit numbers
     * @param {number} lowBits
     * @param {number} highBits
     * @return {!Int64}
     */
    static fromBits(lowBits, highBits) {
        return new Int64(lowBits, highBits);
    }

    /**
     * Constructs an Int64 from a signed 32 bit number.
     * @param {number} value
     * @return {!Int64}
     */
    static fromInt(value) {
        // TODO: Use our own checking system here.
        assert(value === (value | 0), 'value should be a 32-bit integer');
        // Right shift 31 bits so all high bits are equal to the sign bit.
        // Note: cannot use >> 32, because (1 >> 32) = 1 (!).
        const signExtendedHighBits = value >> 31;
        return new Int64(value, signExtendedHighBits);
    }

    /**
     * Constructs an Int64 from a number (over 32 bits).
     * @param {number} value
     * @return {!Int64}
     */
    static fromNumber(value) {
        if (value > 0) {
            return new Int64(value, value / TWO_PWR_32_DBL);
        } else if (value < 0) {
            return negate(-value, -value / TWO_PWR_32_DBL);
        }
        return ZERO;
    }

    /**
     * Construct an Int64 from a signed decimal string.
     * @param {string} value
     * @return {!Int64}
     */
    static fromDecimalString(value) {
        // TODO: Use our own checking system here.
        assert(value.length > 0);
        // The basic Number conversion loses precision, but we can use it for
        // a quick validation that the format is correct and it is an integer.
        assert(Math.floor(Number(value)).toString().length == value.length);
        return decimalStringToInt64(value);
    }

    /**
     * Construct an Int64 from a signed hexadecimal string.
     * @param {string} value
     * @return {!Int64}
     */
    static fromHexString(value) {
        // TODO: Use our own checking system here.
        assert(value.length > 0);
        assert(value.slice(0, 2) == '0x' || value.slice(0, 3) == '-0x');
        const minus = value[0] === '-';
        // Strip the 0x or -0x prefix.
        value = value.slice(minus ? 3 : 2);
        const lowBits = parseInt(value.slice(-8), 16);
        const highBits = parseInt(value.slice(-16, -8) || '', 16);
        return (minus ? negate : Int64.fromBits)(lowBits, highBits);
    }

    // Note to the reader:
    // goog.math.Long suffers from a code size issue. JsCompiler almost always
    // considers toString methods to be alive in a program. So if you are
    // constructing a Long instance the toString method is assumed to be live.
    // Unfortunately Long's toString method makes a large chunk of code alive
    // of the entire class adding 1.3kB (gzip) of extra code size.
    // Callers that are sensitive to code size and are not using Long already
    // should avoid calling this method.
    /**
     * Creates an Int64 instance from a Long value.
     * @param {!Long} value
     * @return {!Int64}
     */
    static fromLong(value) {
        return new Int64(value.getLowBits(), value.getHighBits());
    }

    /**
     * @param {number} lowBits
     * @param {number} highBits
     * @private
     */
    constructor(lowBits, highBits) {
        /** @const @private {number} */
        this.lowBits_ = lowBits | 0;
        /** @const @private {number} */
        this.highBits_ = highBits | 0;
    }

    /**
     * Returns the int64 value as a JavaScript number. This will lose precision
     * if the number is outside of the safe range for JavaScript of 53 bits
     * precision.
     * @return {number}
     */
    asNumber() {
        const result = this.highBits_ * TWO_PWR_32_DBL + this.getLowBitsUnsigned();
        // TODO: Use our own checking system here.
        assert(
            Number.isSafeInteger(result), 'conversion to number loses precision.');
        return result;
    }

    // Note to the reader:
    // goog.math.Long suffers from a code size issue. JsCompiler almost always
    // considers toString methods to be alive in a program. So if you are
    // constructing a Long instance the toString method is assumed to be live.
    // Unfortunately Long's toString method makes a large chunk of code alive
    // of the entire class adding 1.3kB (gzip) of extra code size.
    // Callers that are sensitive to code size and are not using Long already
    // should avoid calling this method.
    /** @return {!Long} */
    asLong() {
        return Long.fromBits(this.lowBits_, this.highBits_);
    }

    /** @return {number} Signed 32-bit integer value. */
    getLowBits() {
        return this.lowBits_;
    }

    /** @return {number} Signed 32-bit integer value. */
    getHighBits() {
        return this.highBits_;
    }

    /** @return {number} Unsigned 32-bit integer. */
    getLowBitsUnsigned() {
        return this.lowBits_ >>> 0;
    }

    /** @return {number} Unsigned 32-bit integer. */
    getHighBitsUnsigned() {
        return this.highBits_ >>> 0;
    }

    /** @return {string} */
    toSignedDecimalString() {
        return joinSignedDecimalString(this);
    }

    /** @return {string} */
    toUnsignedDecimalString() {
        return joinUnsignedDecimalString(this);
    }

    /**
     * Returns an unsigned hexadecimal string representation of the Int64.
     * @return {string}
     */
    toHexString() {
        let nibbles = new Array(16);
        let lowBits = this.lowBits_;
        let highBits = this.highBits_;
        for (let highIndex = 7, lowIndex = 15; lowIndex > 7;
             highIndex--, lowIndex--) {
            nibbles[highIndex] = HEX_DIGITS[highBits & 0xF];
            nibbles[lowIndex] = HEX_DIGITS[lowBits & 0xF];
            highBits = highBits >>> 4;
            lowBits = lowBits >>> 4;
        }
        // Always leave the least significant hex digit.
        while (nibbles.length > 1 && nibbles[0] == '0') {
            nibbles.shift();
        }
        return `0x${nibbles.join('')}`;
    }

    /**
     * @param {*} other object to compare against.
     * @return {boolean} Whether this Int64 equals the other.
     */
    equals(other) {
        if (this === other) {
            return true;
        }
        if (!(other instanceof Int64)) {
            return false;
        }
        // Compare low parts first as there is higher chance they are different.
        const otherInt64 = /** @type{!Int64} */ (other);
        return (this.lowBits_ === otherInt64.lowBits_) &&
            (this.highBits_ === otherInt64.highBits_);
    }

    /**
     * Returns a number (int32) that is suitable for using in hashed structures.
     * @return {number}
     */
    hashCode() {
        return (31 * this.lowBits_ + 17 * this.highBits_) | 0;
    }
}

/**
 * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
 * into a decimal string.
 * @param {!Int64} int64
 * @return {string} The binary number represented as a string.
 */
const joinUnsignedDecimalString = (int64) => {
    const lowBits = int64.getLowBitsUnsigned();
    const highBits = int64.getHighBitsUnsigned();
    // Skip the expensive conversion if the number is small enough to use the
    // built-in conversions.
    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
    // highBits <= 0x1FFFFF can be safely expressed with a double and retain
    // integer precision.
    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
    if (highBits <= 0x1FFFFF) {
        return String(TWO_PWR_32_DBL * highBits + lowBits);
    }

    // What this code is doing is essentially converting the input number from
    // base-2 to base-1e7, which allows us to represent the 64-bit range with
    // only 3 (very large) digits. Those digits are then trivial to convert to
    // a base-10 string.

    // The magic numbers used here are -
    // 2^24 = 16777216 = (1,6777216) in base-1e7.
    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.

    // Split 32:32 representation into 16:24:24 representation so our
    // intermediate digits don't overflow.
    const low = lowBits & LOW_24_BITS;
    const mid = ((lowBits >>> 24) | (highBits << 8)) & LOW_24_BITS;
    const high = (highBits >> 16) & LOW_16_BITS;

    // Assemble our three base-1e7 digits, ignoring carries. The maximum
    // value in a digit at this step is representable as a 48-bit integer, which
    // can be stored in a 64-bit floating point number.
    let digitA = low + (mid * 6777216) + (high * 6710656);
    let digitB = mid + (high * 8147497);
    let digitC = (high * 2);

    // Apply carries from A to B and from B to C.
    const base = 10000000;
    if (digitA >= base) {
        digitB += Math.floor(digitA / base);
        digitA %= base;
    }

    if (digitB >= base) {
        digitC += Math.floor(digitB / base);
        digitB %= base;
    }

    // If digitC is 0, then we should have returned in the trivial code path
    // at the top for non-safe integers. Given this, we can assume both digitB
    // and digitA need leading zeros.
    // TODO: Use our own checking system here.
    assert(digitC);
    return digitC + decimalFrom1e7WithLeadingZeros(digitB) +
        decimalFrom1e7WithLeadingZeros(digitA);
};

/**
 * @param {number} digit1e7 Number < 1e7
 * @return {string} Decimal representation of digit1e7 with leading zeros.
 */
const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
    const partial = String(digit1e7);
    return '0000000'.slice(partial.length) + partial;
};

/**
 * Losslessly converts a 64-bit signed integer in 32:32 split representation
 * into a decimal string.
 * @param {!Int64} int64
 * @return {string} The binary number represented as a string.
 */
const joinSignedDecimalString = (int64) => {
    // If we're treating the input as a signed value and the high bit is set, do
    // a manual two's complement conversion before the decimal conversion.
    const negative = (int64.getHighBits() & 0x80000000);
    if (negative) {
        int64 = negate(int64.getLowBits(), int64.getHighBits());
    }

    const result = joinUnsignedDecimalString(int64);
    return negative ? '-' + result : result;
};

/**
 * @param {string} dec
 * @return {!Int64}
 */
const decimalStringToInt64 = (dec) => {
    // Check for minus sign.
    const minus = dec[0] === '-';
    if (minus) {
        dec = dec.slice(1);
    }

    // Work 6 decimal digits at a time, acting like we're converting base 1e6
    // digits to binary. This is safe to do with floating point math because
    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
    const base = 1e6;
    let lowBits = 0;
    let highBits = 0;

    function add1e6digit(begin, end = undefined) {
        // Note: Number('') is 0.
        const digit1e6 = Number(dec.slice(begin, end));
        highBits *= base;
        lowBits = lowBits * base + digit1e6;
        // Carry bits from lowBits to
        if (lowBits >= TWO_PWR_32_DBL) {
            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
            lowBits = lowBits % TWO_PWR_32_DBL;
        }
    }

    add1e6digit(-24, -18);
    add1e6digit(-18, -12);
    add1e6digit(-12, -6);
    add1e6digit(-6);

    return (minus ? negate : Int64.fromBits)(lowBits, highBits);
};

/**
 * @param {number} lowBits
 * @param {number} highBits
 * @return {!Int64} Two's compliment negation of input.
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
 */
const negate = (lowBits, highBits) => {
    highBits = ~highBits;
    if (lowBits) {
        lowBits = ~lowBits + 1;
    } else {
        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
        // adding 1 to that, results in 0x100000000, which leaves
        // the low bits 0x0 and simply adds one to the high bits.
        highBits += 1;
    }
    return Int64.fromBits(lowBits, highBits);
};

/** @const {!Int64} */
const ZERO = new Int64(0, 0);

/** @const @private {number} */
const LOW_16_BITS = 0xFFFF;

/** @const @private {number} */
const LOW_24_BITS = 0xFFFFFF;

/** @const @private {number} */
const LOW_31_BITS = 0x7FFFFFFF;

/** @const @private {number} */
const ALL_32_BITS = 0xFFFFFFFF;

/** @const {!Int64} */
const MAX_VALUE = Int64.fromBits(ALL_32_BITS, LOW_31_BITS);

/** @const {!Int64} */
const MIN_VALUE = Int64.fromBits(0, 0x80000000);

/** @const {number} */
const TWO_PWR_32_DBL = 0x100000000;

/** @const {string} */
const HEX_DIGITS = '0123456789abcdef';

exports = Int64;
